\documentclass[10.5pt, a4paper]{article}

\usepackage{xeCJK}
\newCJKfontfamily{\heiti}[AutoFakeBold={3.17}]{SimHei}

\usepackage{geometry}
\geometry{
    left = 0.6in,
    right = 0.6in,
    top = 0.8in,
    bottom = 1.0in
}
\usepackage{amssymb,amsbsy,amsmath,xcolor,mathrsfs,graphicx}
\usepackage{listings}
\usepackage{tasks}
\settasks{
    label = \Alph*. ,
    label-width = 16pt
}

\renewcommand{\title}[3]{
    \begin{center}
        \Large\heiti #1~年~#2~月 Python~#3级考试
    \end{center}
}
\newcommand{\TimeAndName}[1]{
    \begin{center}
        考试时间:~#1~ 分钟 \qquad\qquad\qquad\qquad 姓名:\underline{\quad\quad\quad\quad}
    \end{center}
}

\begin{document}
    \lstset{
        language = python,
        keywordstyle = \color{orange}\bfseries,
        emph = {print,bool,chr,ord,sorted,float,type,oct,hex,abs,sum,len,int,open,list,map,str,range,min,max,input},
        emphstyle = \color{purple}\bfseries,
        showspaces = false,
        basicstyle = \ttfamily,
        morekeywords = {True,False}
    }

    \title{2021}{6}{二}
    
    \TimeAndName{60}
    
    \vspace{1cm}
    {\noindent\heiti 第一部分、单选题(共 25 题,每题 2 分,共50分.)}

    \begin{enumerate}
        % 1
        \item 执行下列代码后，运行结果是？(\qquad)
        \begin{lstlisting}
            seq = ['hello', 'good', 'morning']
            s = '*'.join(seq)
            print(s)
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline!hello*good*morning*!
            \task \lstinline!*hello*good*morning!
            \task \lstinline!hello*good*morning!
            \task \lstinline!*hello*good*morning*!
        \end{tasks}
    
        % 2
        \item 小红用一个列表\lstinline!score=[80,78,92,96,100,88,95]!来依次表示她七周的英文测验分数，如果想要查找到第三周的英文测验分数并将其删除，应该怎么做?(\qquad)
        \begin{tasks}(4)
            \task \lstinline!score[3]!
            \task \lstinline!score[2]!
            \task \lstinline!score.pop(3)!
            \task \lstinline!score.pop(2)!
        \end{tasks}

        % 3
        \item 以下代码输出结果是？(\qquad)
        \begin{lstlisting}
            ls = ["2021", "123", "Python"]
            ls.append([2021, "2021"])
            ls.append(2021)
            print(ls)
        \end{lstlisting}
        \begin{tasks}
            \task \lstinline!['2021', '123', 'Python', 2021]!
            \task \lstinline!['2020', '123', 'Python', [2021, '2021']]!
            \task \lstinline!['2021', '123', 'Python', [2021, '2021'], 2021]!
            \task \lstinline!['2020', '123', 'Python', [2021],2021]!
        \end{tasks}

        % 4
        \item 已知\lstinline!Lista=list("five")!，执行语句\lstinline!Lista[2:]=list("rst")!后，列表Lista中的元素为？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!['f', 'i', 'v', 'e', 'r', 's', 't']!
            \task \lstinline!['f', 'r', 's', 't']!
            \task \lstinline!['f', 'i', 'r', 's']!
            \task \lstinline!['f', 'i', 'r', 's', 't']!
        \end{tasks}

        % 5
        \item  原有列表\lstinline!s=[5,2,9,1]!，下列哪个操作不能使得列表s变为\lstinline![9,5,2,1]!？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!s.sort()!\\ \lstinline!s.reverse()! \\ \lstinline!print(s)!
            \task \lstinline!s.sort(reverse=True)!\\ \lstinline!print(s)!
            \task \lstinline!print(sorted(s, reverse=True)!
            \task \lstinline!s.sort()!\\ \lstinline!print(s)!
        \end{tasks}

        % 6
        \item 在Python3.5.2的IDLE交互式环境下依次输入以下程序语句后的结果是?(\qquad)
        \begin{lstlisting}
            >>> S = [10,20,30,40]
            >>> 10 in S
        \end{lstlisting}
        \begin{tasks}(4)
            \task True
            \task true
            \task False
            \task false
        \end{tasks}

        % 7
        \item 以下代码输出结果是？(\qquad)
        \begin{lstlisting}
            ls = [888, 'note', [2021, 'Python', 123], 20]
            print(ls[2][1])
        \end{lstlisting}
        \begin{tasks}(4)
            \task note
            \task Python
            \task 2021
            \task 结果错误
        \end{tasks}

        \newpage
        % 8
        \item  已知a="123"，那么a*2的结果是?(\qquad)
        \begin{tasks}(4)
            \task 246
            \task 123123
            \task '123123'
            \task '246'
        \end{tasks}

        % 9
        \item 执行下列代码后，屏幕打印的k值的个数共有多少个?(\qquad)
        \begin{lstlisting}
            k = 100
            while k>1:
                print(k)
                k = k//2
        \end{lstlisting}
        \begin{tasks}(4)
            \task 5
            \task 6
            \task 10
            \task 50
        \end{tasks}

        % 10
        \item  据相关文件规定，全国景区对老年人实行优惠政策：60岁以内全票，60-69岁（含60岁和69岁）的老年人半票，69岁以上免费。输入年龄，可以输出全票/半票/免费信息的程序是?(\qquad)
        \begin{tasks}(4)
            \task \includegraphics[width=.18\textwidth]{10a.png}
            \task \includegraphics[width=.18\textwidth]{10b.png}
            \task \includegraphics[width=.18\textwidth]{10c.png}
            \task \includegraphics[width=.18\textwidth]{10d.png}
        \end{tasks}

        % 11
        \item 将下列列表a中偶数提取出来并形成一个新的列表c，请补充完整语句？(\qquad)
        \begin{lstlisting}
            a = [3,5,7,6,2,8,10]
            c = []
            for i in a:
                if ______:
                    ______
            print(c)
        \end{lstlisting}
        \begin{tasks}(4)
            \task \lstinline!i\%2==0! \\ \lstinline!c.append(i)!
            \task \lstinline!i\%2==0! \\ \lstinline!c.extend(i)!
            \task \lstinline!i//2==0! \\ \lstinline!c.append(i)!
            \task \lstinline!i//2==0! \\ \lstinline!c.extend(i)!
        \end{tasks}

        % 12
        \item  下列说法错误的是？(\qquad)
        \begin{tasks}(2)
            \task 字典是可变的无序集合
            \task 列表、元组可以相互嵌套使用
            \task 字典虽然不能利用下标访问元素，但可以排序
            \task 字典属于一对一映射关系的数据类型
        \end{tasks}

        % 13
        \item  以下说法正确的是?(\qquad)
        \begin{tasks}(2)
            \task 同一个元组中，元素的类型必须相同
            \task tuple()函数可以将列表转换为元组
            \task 用del就可以删除元组中的元素
            \task 列表和元组都是可变数据类型
        \end{tasks}

        % 14
        \item 关于下列程序理解说法正确的是?(\qquad)
        \begin{lstlisting}
            num = 0
            while num<10:
                print("Python")
        \end{lstlisting}
        \begin{tasks}
            \task 在while代码块中无论加什么都不能改变死循环
            \task 运行结果打印输出10个"Python"语句
            \task 这个while循环是一个死循环,会一直打印"Python"
            \task 在while代码块中加一行代码num-=1可以改变死循环
        \end{tasks}
        
        % \newpage
        % 15
        \item 下列程序的运行结果是?(\qquad)
        \begin{lstlisting}
            name = 'The dog is ehite'
            new_name = name[:11] + 'white'
            print(new_name[11:])
        \end{lstlisting}
        \begin{tasks}(4)
            \task The dog is white
            \task hite
            \task ehite
            \task white
        \end{tasks}

        % 16
        \item 正确定义元组yuan的语句是?(\qquad)
        \begin{tasks}(4)
            \task \lstinline!yuan = {1,2,3}!
            \task \lstinline!yuan = [1,2,3]!
            \task \lstinline!yuan = (1,2,3)!
            \task \lstinline!yuan = <1,2,3>!
        \end{tasks}

        % 17
        \item 已知列表\lstinline!List1=[1,2,3,4,5]!，要在列表List1中的最前面添加元素0，则下列操作可行的是?(\qquad)
        \begin{tasks}(2)
            \task \lstinline!List1 = 0+List1!
            \task \lstinline!List1 = "0"+List1!
            \task \lstinline!List1 = [0] + List1!
            \task \lstinline!List1 = List1 + [0]!
        \end{tasks}

        % 18
        \item 已知列表\lstinline!a=[1,2,3]!，执行语句\lstinline!print(2*a)!，显示的结果是?(\qquad)
        \begin{tasks}(2)
            \task \lstinline![2,4,6]!
            \task \lstinline![1,2,3,1,2,3]!
            \task \lstinline![1,2,3,2,4,6]!
            \task \lstinline![1,2,3,3,2,1]!
        \end{tasks}

        % 19
        \item  执行下列代码后，运行结果是?(\qquad)
        \begin{lstlisting}
            for i in range(0,10,2):
                print(i*2, end=',')
        \end{lstlisting}
        \begin{tasks}(4)
            \task 0,\\ 4,\\ 8,\\ 12, \\ 16,
            \task 0,4,8,12,16,
            \task 2,\\ 6,\\ 10,\\ 14,\\ 18,
            \task 2,6,10,14,18,
        \end{tasks}

        % 20
        \item 以下是一个猜数字程序，当输入的数字大于目标数字（本程序指定为5）时，提示“大了”；当小于时，提示“小了”；当相等时，提示“相等”，程序退出。程序中空白处分别应填入的代码是?(\qquad)
        \begin{lstlisting}
            a = 5
            while True:
                b = int(input("输入数字:"))
                if (b>a):
                    print("大了")
                ______ (b<a):
                    print("小了")
                else:
                    print("相等")
                    ______
        \end{lstlisting}
        \begin{tasks}(4)
            \task \lstinline!if! \\ \lstinline!break!
            \task \lstinline!else! \\ \lstinline!break!
            \task \lstinline!elif! \\ \lstinline!break!
            \task \lstinline!elif! \\ \lstinline!continue!
        \end{tasks}

        % 21
        \item 执行以下语句，程序将输出？(\qquad)
        \begin{lstlisting}
            yuan = 2,3,1,4,6,5
            list1 = sorted(yuan)
            list1
        \end{lstlisting}
        \begin{tasks}(4)
            \task 报错
            \task 1，2，3，4，5，6
            \task (1，2，3，4，5，6)
            \task \lstinline![1，2，3，4，5，6]!
        \end{tasks}

        % 22
        \item 下列有关字典对象的说法，不正确的是?(\qquad)
        \begin{tasks}
            \task 字典中的值可以是任意类型的数据
            \task 字典中的每个元素包含键和值两部分
            \task 在同一个字典中，键值必须互不相同
            \task 可以通过字典的键找到对应的值，也可以通过值来找到对应的键
        \end{tasks}

        % 23
        \item 以下不属于Python语言流程控制结构的是?(\qquad)
        \begin{tasks}(4)
            \task 顺序结构
            \task 分支结构
            \task 数据结构
            \task 循环结构
        \end{tasks}

        \newpage
        % 24
        \item 已知字典\lstinline!dict1={0:"zero",1:"one",2:"two",3:"Three"}!，执行语句\lstinline!dict1[3]="three"!后，字典dict1的内容为？(\qquad)
        \begin{tasks}
            \task \lstinline!\{0:"zero", 1:"one", 2:"two", 3:"Three"\}!
            \task \lstinline!\{0:"zero", 1:"one", 2:"two", 3:"three"\}!
            \task \lstinline!\{0:"zero", 1:"one", 2:"two", "3":three\}!
            \task \lstinline!\{0:"zero", 1:"one", 2:"two", 3:"Three", 3:"three"\}!
        \end{tasks}

        % 25
        \item 用语句\lstinline!mydict={'a':1,'b':2,'c':3,'d':4}!定义了一个字典，以下语句中，可以输出字典键值的是？(\qquad)
        \begin{tasks}(4)
            \task \lstinline!print(mydict('c'))!
            \task \lstinline!print(mydict 'c')!
            \task \lstinline!mydict['c']!
            \task \lstinline!print(mydict\{'c'\})!
        \end{tasks}
    \end{enumerate}

    \vspace{1cm}
    {\noindent\heiti 第二部分、判断题(共 10 题,每题 2 分,共20分.)}
    \begin{enumerate}
        \setcounter{enumi}{25}
        % 26
        \item \lstinline!for-in!用于在某范围内的循环，循环范围是有限的.(\qquad)

        %27
        \item 元组的定义方法与列表完全相同.(\qquad)
        
        %28
        \item 字典中的键必须是唯一的，必须是不可变数据类型，如字符串、数字或列表.(\qquad)
  
        %29
        \item 字符串中的元素是通过索引来定位的，其中第一个元素的索引是0.(\qquad)
        
        %30
        \item 下面程序打印结果最后一个数是10.(\qquad)
        \begin{lstlisting}
            a = 0
            while a<10:
                a += 1
                print(a, end="")
        \end{lstlisting}
        
        %31
        \item  Python程序的分支结构分为单分支结构、二分支结构和多分支结构，可用\lstinline!if!语句来实现.(\qquad)
        
        %32
        \item 表达式\lstinline!"abc" in ["abcdef"]! 的值为\lstinline!True!.(\qquad)
        
        %33
        \item \lstinline!'red' in ('yellow','red','purple')! 的结果为\lstinline!True!.(\qquad)
        
        %34
        \item Python程序设计语言中的循环结构可用\lstinline!while!或\lstinline!for!语句来实现，所有的\lstinline!while!语句均可用\lstinline!for!语句来实现.(\qquad)
        
        %35
        \item 运行下列代码后，list1的值35. 运行下列代码后，list1的值为['a',1,2,3,7].(\qquad)
        \begin{lstlisting}
            list1 = [1,3,'a',2,7]
            list1.sort()
        \end{lstlisting}
    \end{enumerate}

    % \newpage
    {\noindent\heiti 第三部分、编程题(共 2 题,共30分.)}
    \begin{enumerate}
        \setcounter{enumi}{35}
        
        % 36
        \item 没有重复数字的两位数统计,要求如下：
        
        \begin{tasks}[label=\arabic*.]
            \task 检查所有的两位数；
            \task 程序自动分析两位数上的个位与十位上的数字是否相同；相同则剔除，不同则保留（例如：12符合本要求，个位是2，十位是1，两个不相同）；
            \task 统计符合上面要求的两位数的个数，并且将个数最后打印出来（注意：是个数打印出来，符合要求的两位数不要求打印出来）。
        \end{tasks}
        \vfill

        %37
        \item 编写一段程序程序，实现输入的数字自动改为对应的星期几,要求如下:
        
        \begin{tasks}[label=\arabic*.]
            \task 当输入1时，输出：1 —— 星期一；
            \task 当输入2时，输出：2 —— 星期二......以此类推;
            \task 当输入7时，输出：7 —— 星期日;
            \task 注意，程序运行后，用户是随机输入数字1-7.
        \end{tasks}
        \vfill
    \end{enumerate}

    \newpage
    \begin{center}
        \Huge \heiti 参考答案
    \end{center}

        \begin{tasks}[label=\arabic*.](5)
            \task C
            \task D
            \task C
            \task D
            \task D

            \task A
            \task B
            \task C
            \task B
            \task B

            \task A
            \task C
            \task B
            \task C
            \task D

            \task C
            \task C
            \task B
            \task B
            \task C

            \task D
            \task D
            \task C
            \task B
            \task C

            \task $\checkmark$
            \task $\times$
            \task $\checkmark$
            \task $\checkmark$
            \task $\checkmark$

            \task $\checkmark$
            \task $\times$
            \task $\checkmark$
            \task $\times$
            \task $\times$
        \end{tasks}

        \begin{enumerate}
            \setcounter{enumi}{35}
            \item \begin{lstlisting}
                ls = [11, 22, 34, 56, 78, 90, 134, 133, 178, 99]
                total = 0
                for i in ls:
                    if 9 < i < 100 and i//10 == i%10:
                            total += 1

                print(total)
            \end{lstlisting}

            \item \begin{lstlisting}
                weeks = [' ', '一', '二', '三', '四', '五', '六', '日']

                while True:
                    week = int(input("输入数字:"))
                    print(week, "———— 星期" + weeks[week])
            \end{lstlisting}
        \end{enumerate}
\end{document}